Java 读书笔记10 内部类

内部类

可访问外围类

  1. 外围类就是包含内部类的那个类的啦
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    public class Sequence {
        private  Object[] items= new Object[5];
        private  class  SequenceSelector implements  Selector
        {
            private  int i ;
            @Override
            public boolean end() {
                return 1==items.length;         //直接访问了内部类属性；
            }
        }
        public  Selector selector ()
        {
            return  new SequenceSelector();
        }
        public  static  void  main (String a[])
        {
            Sequence sequence = new Sequence();
           Selector selector =  sequence.selector();
            System.out.println(selector.end());
        }
    }

this 与new

  1. this是返回类自身的一个对象；
  2. 外部类的.new方法，用于初始化一个内部类对象
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    public class DoThis {
        inner inner = new inner();
        private  class  inner          //访问无限制；
        {
            public inner in()
            {
                return  inner.this;
            }
        }
        public  static  void  main(String a[])
        {
            DoThis doThis = new DoThis();
            DoThis.inner inner = doThis.new inner();
            System.out.println(inner.equals(inner.in()));   //输出为true
            inner in = new inner(); //报错，（即便内部类为public），解决方案显示，要不将内部类static，变成嵌套类；要不main函数去掉static ，这样就变成外围类的小函数喽；
        }
    }

ps：在拥有外部类之前，是不能创建内部类的；内部类对象会偷偷连接到外部类对象；嵌套类除外，就是内部类前面加static；嵌套类基本是说外部类可以访问内部类，而内部类不可直接访问内部类；

内部类与向上转型；

1.大概讲了接口分离吧，没感觉的说。。。。

在方法和作用域中的内部类

1.当一个类只在某处使用，而又不想公开，就可以写在方法或作用域中

1
2
3
4
5
6
7
8
9
10
11
12
public void test()
{
    class  a{        //class前面不可有访问控制符；
        
    }
    if (true)
    {
        class  b {
            
        }
    }
}

匿名类 （重点喽）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class Parcel7 {
    public  Selector selector ()      //Selector是接口
    {
        return  new Selector() {     //直接返回一个对象，没有引用，也就是对象的名字
            @Override
            public boolean end() {    //接口需要重写方法；
                return false;
            }
        };
    }
    class  selector implements  Selector   //原始版本
    {
        @Override
        public boolean end() {
            return false;
        }
    }
    public  Selector selector02()
    {
        return  new selector();
    }
}

1.从上面可以看出，在没有匿名类时。我们需要使用接口就得新建一个类，为了方便就可以创建内部类；但是类本身生成对象没有用啊，于是我们可能就得用函数，或者外围类来创建它；而假设我们只是想得到一个对象，这样太麻烦了；匿名类就简化了这样的步骤；
2.相当于什么呢，现在我们需要一个泥瓦罐，平常得先继承啊什么的，匿名类，直接上一个泥瓦罐交差了；

上面的是接口，如果是继承呢？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class Wrapping {
    private  int i ;
    public  Wrapping(int x)
    {
        i = x;
    }
    public void a()
    {
        
    }
}
public class Parcel7 {
  public  Wrapping wrapping ()
    {
        return  new Wrapping(1) //这里也可以直接初始化
        {
            @Override          //只能重写
            public void a() {      
            }
        };
    }
}

1. 当匿名类继承自类时，实际上是把它作为接口使用，无法重载；
2. 匿名内部类只能继承或只能实现接口，不可重载；

再访工厂方法

设计模式还是到时候一起看吧

嵌套类

感觉没啥用啊

  1. 嵌套类的创建不需要外部类；也就是说你写在内部，写在外部没有区别
  2. 不能从嵌套类对象访问非静态的外围类的对象。 只能访问静态对象，要你何用？
  3. 一个嵌套类不管嵌套多深，都可以访问外部类；
  4. 但是我们发现，当嵌套类放在接口中的时候，他就可以顺利成章的被所有实现接口的类所使用（接口自动就是static ，所以内部类不好使）
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    public interface ClassInterface {
        void howdy();
        class  test implements  ClassInterface
        {
            @Override
            public void howdy() {
                System.out.println("out");
            }
            void  a ()         //a方法就不行啦
            {
                System.out.println("a");
            }
        }
    }
    public class ClassIner implements  ClassInterface {
        @Override
        public void howdy() {
        }
        public static  void  main(String a[])
        {
            ClassIner classIner = new ClassIner();
            classIner.howdy();
            new  test().howdy();    //不声明接口无法调用
        }
    }

内部类到底有啥用处？

1.  首先一个内部类创建时就和一和一个外围类的对象绑定；可以访问外围类中的属性；
2. 内部类可以有多个；他们可以实现接口或者继承；

于是我们可以推出的是：

1. 当内部类对象被创建时，这个对象是可以操作外围类数据的；这就好像外围类自己的方法操作自己的方法一样；然而，内部类可以继承，可以接口；所以方法一下子就变多了；等于外围类实现了多重继承；
2. 然而却不是多重继承；我们在继承的时候，留下了方法，留下了属性；然而有些时候我们只希望用一下你们家的方法，不想要属性；（想要属性那是抽象类）这种事情很多，就有了接口，谁想用用呗；只要自己想办法实现；然而这样不能用继承啊，而且接口多的话好麻烦啊，整个类变得臃肿不堪

最后呢，举个例子：

  1. 期初有一家公司
  2. 这家公司随着时间总得换新boss吧；然后就继承出了新的公司；
  3. 随着时间又该换boss啦，老头看了看不争气的儿子；就把公司的几个部门的老大解雇了，说到：我把这些人解雇，部门还留着，但是具体实现就得靠你了；这时就是抽象类了；
  4. 随着时间过去了很久，市场有了天翻地覆的变化，网络啊，手机啊；这家公司不知所措，就别人做什么他也做什么；经常是使用公司的全力向某个方向发展；然后活下去了；这就叫做接口；
  5. 但是随着接口越来越多，公司的发展方向越来越多；很难再倾尽公司之力，于是就分为子公司专做这个；这就是内部类
  6. 随着时间的消逝，你可能已经忘了最初的那家公司了，因为它全身插满了管子，通往四面八方；

闭包

闭包（Closure）是一种能被调用的对象，它保存了创建它的作用域的信息。JAVA并不能显式地支持闭包，但是在JAVA中，闭包可以通过“接口+内部类”来实现。
例如：一个接口程序员和一个基类作家都有一个相同的方法work，相同的方法名，但是其含义完全不同，这时候就需要闭包。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class Writer {//作家基类
  void work(){};
}
interface programmer{//程序员接口
  void work();
}
闭包实现代码如下：
public class WriterProgrammer extends Writer {
  @Override
  public void work(){
      //写作
  }
  public void code(){
      //写代码
  }
  class ProgrammerInner implements programmer{
      @Override
      public void work(){
          code();
      }
  }
}

在子类中定义了遵循程序员接口规则的内部类，然后使用内部类实现程序员的work()方法回调code()方法，在子类中直接实现父类作家的work()方法。

继续跑<br><br>带着赤子的骄傲